{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys \n",
    "\n",
    "# Modify the path \n",
    "sys.path.append(\"..\")\n",
    "\n",
    "import yellowbrick as yb\n",
    "import matplotlib.ticker as ticker\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setup a plot such that only the bottom spine is shown\n",
    "def setup(ax):\n",
    "    ax.spines['right'].set_color('none')\n",
    "    ax.spines['left'].set_color('none')\n",
    "    ax.yaxis.set_major_locator(ticker.NullLocator())\n",
    "    ax.spines['top'].set_color('none')\n",
    "    ax.xaxis.set_ticks_position('bottom')\n",
    "    ax.tick_params(which='major', width=1.00)\n",
    "    ax.tick_params(which='major', length=5)\n",
    "    ax.tick_params(which='minor', width=0.75)\n",
    "    ax.tick_params(which='minor', length=2.5)\n",
    "    ax.set_xlim(0, 5)\n",
    "    ax.set_ylim(0, 1)\n",
    "    ax.patch.set_alpha(0.0)\n",
    "\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "n = 8\n",
    "\n",
    "# Multiple Locator\n",
    "ax_ = plt.subplot(n, 1, 2)\n",
    "setup(ax_)\n",
    "ax_.xaxis.set_major_locator(ticker.MultipleLocator(0.5))\n",
    "#ax_.xaxis.set_minor_locator(ticker.MultipleLocator(0.1))\n",
    "#ax_.text(0.0, 0.1, \"MultipleLocator(0.5)\", fontsize=14, transform=ax_.transAxes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# yellowbrick.cluster.silhouette\n",
    "# Implements visualizers using the silhouette metric for cluster evaluation.\n",
    "#\n",
    "# Author:   Benjamin Bengfort <bbengfort@districtdatalabs.com>\n",
    "# Created:  Mon Mar 27 10:09:24 2017 -0400\n",
    "#\n",
    "# Copyright (C) 2016 District Data Labs\n",
    "# For license information, see LICENSE.txt\n",
    "#\n",
    "# ID: silhouette.py [57b563b] benjamin@bengfort.com $\n",
    "\n",
    "\"\"\"\n",
    "Implements visualizers that use the silhouette metric for cluster evaluation.\n",
    "\"\"\"\n",
    "\n",
    "##########################################################################\n",
    "## Imports\n",
    "##########################################################################\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from yellowbrick.style import color_palette\n",
    "from yellowbrick.cluster.base import ClusteringScoreVisualizer\n",
    "\n",
    "from sklearn.metrics import silhouette_score, silhouette_samples\n",
    "\n",
    "\n",
    "## Packages for export\n",
    "__all__ = [\n",
    "    \"SilhouetteVisualizer\"\n",
    "]\n",
    "\n",
    "\n",
    "##########################################################################\n",
    "## Silhouette Method for K Selection\n",
    "##########################################################################\n",
    "\n",
    "class SilhouetteVisualizer(ClusteringScoreVisualizer):\n",
    "    \"\"\"\n",
    "    The Silhouette Visualizer displays the silhouette coefficient for each\n",
    "    sample on a per-cluster basis, visually evaluating the density and\n",
    "    separation between clusters. The score is calculated by averaging the\n",
    "    silhouette coefficient for each sample, computed as the difference\n",
    "    between the average intra-cluster distance and the mean nearest-cluster\n",
    "    distance for each sample, normalized by the maximum value. This produces a\n",
    "    score between -1 and +1, where scores near +1 indicate high separation\n",
    "    and scores near -1 indicate that the samples may have been assigned to\n",
    "    the wrong cluster.\n",
    "\n",
    "    In SilhouetteVisualizer plots, clusters with higher scores have wider\n",
    "    silhouettes, but clusters that are less cohesive will fall short of the\n",
    "    average score across all clusters, which is plotted as a vertical dotted\n",
    "    red line.\n",
    "\n",
    "    This is particularly useful for determining cluster imbalance, or for\n",
    "    selecting a value for K by comparing multiple visualizers.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model : a Scikit-Learn clusterer\n",
    "        Should be an instance of a centroidal clustering algorithm (``KMeans``\n",
    "        or ``MiniBatchKMeans``).\n",
    "\n",
    "    ax : matplotlib Axes, default: None\n",
    "        The axes to plot the figure on. If None is passed in the current axes\n",
    "        will be used (or generated if required).\n",
    "\n",
    "    kwargs : dict\n",
    "        Keyword arguments that are passed to the base class and may influence\n",
    "        the visualization as defined in other Visualizers.\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    silhouette_score_ : float\n",
    "        Mean Silhouette Coefficient for all samples. Computed via scikit-learn\n",
    "        `sklearn.metrics.silhouette_score`.\n",
    "\n",
    "    silhouette_samples_ : array, shape = [n_samples]\n",
    "        Silhouette Coefficient for each samples. Computed via scikit-learn\n",
    "        `sklearn.metrics.silhouette_samples`.\n",
    "\n",
    "    n_samples_ : integer\n",
    "        Number of total samples in the dataset (X.shape[0])\n",
    "\n",
    "    n_clusters_ : integer\n",
    "        Number of clusters (e.g. n_clusters or k value) passed to internal\n",
    "        scikit-learn model.\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "\n",
    "    >>> from yellowbrick.cluster import SilhouetteVisualizer\n",
    "    >>> from sklearn.cluster import KMeans\n",
    "    >>> model = SilhouetteVisualizer(KMeans(10))\n",
    "    >>> model.fit(X)\n",
    "    >>> model.poof()\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, model, ax=None, **kwargs):\n",
    "        super(SilhouetteVisualizer, self).__init__(model, ax=ax, **kwargs)\n",
    "\n",
    "        # Visual Properties\n",
    "        # TODO: Fix the color handling\n",
    "        self.colormap = kwargs.get('colormap', 'set1')\n",
    "        self.color = kwargs.get('color', None)\n",
    "\n",
    "    def fit(self, X, y=None, **kwargs):\n",
    "        \"\"\"\n",
    "        Fits the model and generates the silhouette visualization.\n",
    "        \"\"\"\n",
    "        # TODO: decide to use this method or the score method to draw.\n",
    "        # NOTE: Probably this would be better in score, but the standard score\n",
    "        # is a little different and I'm not sure how it's used.\n",
    "\n",
    "        # Fit the wrapped estimator\n",
    "        self.estimator.fit(X, y, **kwargs)\n",
    "\n",
    "        # Get the properties of the dataset\n",
    "        self.n_samples_ = X.shape[0]\n",
    "        self.n_clusters_ = self.estimator.n_clusters\n",
    "\n",
    "        # Compute the scores of the cluster\n",
    "        labels = self.estimator.predict(X)\n",
    "        self.silhouette_score_ = silhouette_score(X, labels)\n",
    "        self.silhouette_samples_ = silhouette_samples(X, labels)\n",
    "\n",
    "        # Draw the silhouette figure\n",
    "        self.draw(labels)\n",
    "\n",
    "        # Return the estimator\n",
    "        return self\n",
    "\n",
    "    def draw(self, labels):\n",
    "        \"\"\"\n",
    "        Draw the silhouettes for each sample and the average score.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "\n",
    "        labels : array-like\n",
    "            An array with the cluster label for each silhouette sample,\n",
    "            usually computed with ``predict()``. Labels are not stored on the\n",
    "            visualizer so that the figure can be redrawn with new data.\n",
    "        \"\"\"\n",
    "\n",
    "        # Track the positions of the lines being drawn\n",
    "        y_lower = 10 # The bottom of the silhouette\n",
    "\n",
    "        # Get the colors from the various properties\n",
    "        # TODO: Use resolve_colors instead of this\n",
    "        colors = color_palette(self.colormap, self.n_clusters_)\n",
    "\n",
    "        # For each cluster, plot the silhouette scores\n",
    "        for idx in range(self.n_clusters_):\n",
    "\n",
    "            # Collect silhouette scores for samples in the current cluster .\n",
    "            values = self.silhouette_samples_[labels == idx]\n",
    "            values.sort()\n",
    "\n",
    "            # Compute the size of the cluster and find upper limit\n",
    "            size = values.shape[0]\n",
    "            y_upper = y_lower + size\n",
    "\n",
    "            color = colors[idx]\n",
    "            self.ax.fill_betweenx(\n",
    "                np.arange(y_lower, y_upper), 0, values,\n",
    "                facecolor=color, edgecolor=color, alpha=0.5\n",
    "            )\n",
    "\n",
    "            # Label the silhouette plots with their cluster numbers\n",
    "            self.ax.text(-0.05, y_lower + 0.5 * size, str(idx))\n",
    "            \n",
    "            # Compute the new y_lower for next plot\n",
    "            y_lower = y_upper + 10\n",
    "\n",
    "        # The vertical line for average silhouette score of all the values\n",
    "        self.ax.axvline(\n",
    "            x=self.silhouette_score_, color=\"red\", linestyle=\"--\"\n",
    "        )\n",
    "\n",
    "        return self.ax\n",
    "\n",
    "    def finalize(self):\n",
    "        \"\"\"\n",
    "        Prepare the figure for rendering by setting the title and adjusting\n",
    "        the limits on the axes, adding labels and a legend.\n",
    "        \"\"\"\n",
    "\n",
    "        # Set the title\n",
    "        self.set_title((\n",
    "            \"Silhouette Plot of {} Clustering for {} Samples in {} Centers\"\n",
    "        ).format(\n",
    "            self.name, self.n_samples_, self.n_clusters_\n",
    "        ))\n",
    "\n",
    "        # Set the X and Y limits\n",
    "        # The silhouette coefficient can range from -1, 1;\n",
    "        # but here we scale the plot according to our visualizations\n",
    "        \n",
    "        # l_xlim and u_xlim are lower and upper limits of the x-axis, \n",
    "        # set according to our calculated maximum and minimum silhouette score along with necessary padding\n",
    "        l_xlim = max(-1, min(-0.1, round(min(self.silhouette_samples_)-0.1,1)))\n",
    "        u_xlim = min(1, round(max(self.silhouette_samples_)+0.1,1))\n",
    "        self.ax.set_xlim([l_xlim, u_xlim])\n",
    "\n",
    "        # The (n_clusters_+1)*10 is for inserting blank space between\n",
    "        # silhouette plots of individual clusters, to demarcate them clearly.\n",
    "        self.ax.set_ylim([0, self.n_samples_ + (self.n_clusters_ + 1) * 10])\n",
    "\n",
    "        # Set the x and y labels\n",
    "        self.ax.set_xlabel(\"silhouette coefficient values\")\n",
    "        self.ax.set_ylabel(\"cluster label\")\n",
    "\n",
    "        # Set the ticks on the axis object.\n",
    "        self.ax.set_yticks([])  # Clear the yaxis labels / ticks\n",
    "        self.ax.xaxis.set_major_locator(ticker.MultipleLocator(0.1)) # Set the ticks at multiples of 0.1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_blobs\n",
    "\n",
    "# Make blobs dataset\n",
    "X, y = make_blobs(n_samples=1000, n_features=12, centers=8, shuffle=False, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.cluster import KMeans\n",
    "# Instantiate the clustering model and visualizer\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot()\n",
    "\n",
    "model = KMeans(random_state=0)\n",
    "visualizer = SilhouetteVisualizer(model, ax=ax)\n",
    "\n",
    "visualizer.fit(X) # Fit the training data to the visualizer\n",
    "visualizer.poof() # Draw/show/poof the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = KMeans(n_clusters=2, random_state=0)\n",
    "visualizer = SilhouetteVisualizer(model, ax=ax)\n",
    "\n",
    "visualizer.fit(X) # Fit the training data to the visualizer\n",
    "visualizer.poof() # Draw/show/poof the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.cluster import MiniBatchKMeans\n",
    "# Instantiate the clustering model and visualizer\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot()\n",
    "\n",
    "model = MiniBatchKMeans(random_state=0)\n",
    "visualizer = SilhouetteVisualizer(model, ax=ax)\n",
    "\n",
    "visualizer.fit(X) # Fit the training data to the visualizer\n",
    "visualizer.poof() # Draw/show/poof the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = MiniBatchKMeans(n_clusters=12, random_state=0)\n",
    "visualizer = SilhouetteVisualizer(model, ax=ax)\n",
    "\n",
    "visualizer.fit(X) # Fit the training data to the visualizer\n",
    "visualizer.poof() # Draw/show/poof the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
